package org.alwayssuper.protocol.commons.transform.realtimev2025;

import org.alwayssuper.protostar.annotation.Field;
import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.List;

/**
 * 2025版超级电容器数据格式 (0x31)
 * 参考AICoding报文规则文档 - 2025版新增
 * @author alwaysSuper
 */
@ToString
@Data
@Accessors(chain = true)
public class SupercapacitorData {
    @Field(length = 1, desc = "超级电容管理系统号:有效值范围1~253")
    private int supercapacitorManagementSystemNo;
    
    @Field(length = 2, desc = "超级电容总电压:有效值范围0~10000(表示0V~1000V),精度0.1V,0xFFFF表示无效")
    private int totalVoltage;
    
    @Field(length = 2, desc = "超级电容总电流:有效值范围0~60000(偏移3000A,-3000A~+3000A),精度0.1A,0xFFFF表示无效")
    private int totalCurrent;
    
    // 超级电容单体总数:M个单体,有效值范围:1~65531(由supercapacitorCellVoltages的totalUnit获取)
    private int supercapacitorCellCount;
    
    @Field(totalUnit = 2, desc = "超级电容单体电压列表")
    private List<SupercapacitorCellVoltage> supercapacitorCellVoltages;
    
    // 超级电容温度探针总数:N个探针,有效值范围:1~65531(由temperatureValues的totalUnit获取)
    private int temperatureProbeCount;
    
    @Field(totalUnit = 2, desc = "探针温度值列表")
    private List<TemperatureValue> temperatureValues;
    
    // ==================== 传输值与真实值转换方法 ====================
    
    /**
     * 获取超级电容总电压 (V)
     * @return 总电压，精度0.1V，异常返回-1，无效返回-2
     */
    public double getTotalVoltage() {
        if (totalVoltage == 0xFFFE) return -1.0; // 异常
        if (totalVoltage == 0xFFFF) return -2.0; // 无效
        return totalVoltage * 0.1; // 传输值×0.1 = 值(V)
    }
    
    /**
     * 设置超级电容总电压 (V)
     * @param voltage 总电压值，范围0~1000V
     */
    public void setTotalVoltage(double voltage) {
        if (voltage < 0 || voltage > 1000.0) {
            this.totalVoltage = 0xFFFF; // 无效值
        } else {
            this.totalVoltage = (int) Math.round(voltage * 10); // 值×10 = 传输值
        }
    }
    
    /**
     * 获取超级电容总电流 (A)
     * @return 总电流，精度0.1A，异常返回-9999，无效返回-10000
     */
    public double getTotalCurrent() {
        if (totalCurrent == 0xFFFE) return -9999.0; // 异常
        if (totalCurrent == 0xFFFF) return -10000.0; // 无效
        return (totalCurrent - 30000) * 0.1; // (传输值-30000)×0.1 = 值(A)，支持负值
    }
    
    /**
     * 设置超级电容总电流 (A)
     * @param current 总电流值，范围-3000A~+3000A
     */
    public void setTotalCurrent(double current) {
        if (current < -3000.0 || current > 3000.0) {
            this.totalCurrent = 0xFFFF; // 无效值
        } else {
            this.totalCurrent = (int) Math.round(current * 10 + 30000); // (值×10)+30000 = 传输值
        }
    }
    
    /**
     * 检查超级电容总电压是否有效
     * @return true: 有效, false: 异常或无效
     */
    public boolean isTotalVoltageValid() {
        return totalVoltage != 0xFFFE && totalVoltage != 0xFFFF;
    }
    
    /**
     * 检查超级电容总电流是否有效
     * @return true: 有效, false: 异常或无效
     */
    public boolean isTotalCurrentValid() {
        return totalCurrent != 0xFFFE && totalCurrent != 0xFFFF;
    }
    
    @Data
    @Accessors(chain = true)
    public static class SupercapacitorCellVoltage {
        @Field(length = 2, desc = "超级电容单体电压:有效值范围0~60000(表示0V~60.000V),精度0.001V")
        private int cellVoltage;
        
        // ==================== 传输值与真实值转换方法 ====================
        
        /**
         * 获取超级电容单体电压 (V)
         * @return 电压，精度0.001V，异常返回-1，无效返回-2
         */
        public double getCellVoltage() {
            if (cellVoltage == 0xFFFE) return -1.0; // 异常
            if (cellVoltage == 0xFFFF) return -2.0; // 无效
            return cellVoltage * 0.001; // 传输值×0.001 = 值(V)
        }
        
        /**
         * 设置超级电容单体电压 (V)
         * @param voltage 电压值，范围0~60.000V
         */
        public void setCellVoltage(double voltage) {
            if (voltage < 0 || voltage > 60.0) {
                this.cellVoltage = 0xFFFF; // 无效值
            } else {
                this.cellVoltage = (int) Math.round(voltage * 1000); // 值×1000 = 传输值
            }
        }
        
        /**
         * 检查超级电容单体电压是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isCellVoltageValid() {
            return cellVoltage != 0xFFFE && cellVoltage != 0xFFFF;
        }
    }
    
    @Data
    @Accessors(chain = true)
    public static class TemperatureValue {
        @Field(length = 1, desc = "探针温度值:有效值范围0~250(偏移40℃,-40℃~+210℃),精度1℃")
        private int temperatureValue;
        
        // ==================== 传输值与真实值转换方法 ====================
        
        /**
         * 获取探针温度值 (℃)
         * @return 温度，精度1℃，异常返回-999，无效返回-1000
         */
        public int getTemperatureValue() {
            if (temperatureValue == 0xFE) return -999; // 异常
            if (temperatureValue == 0xFF) return -1000; // 无效
            return temperatureValue - 40; // (传输值-40) = 值(℃)，支持负值
        }
        
        /**
         * 设置探针温度值 (℃)
         * @param temperature 温度值，范围-40℃~+210℃
         */
        public void setTemperatureValue(int temperature) {
            if (temperature < -40 || temperature > 210) {
                this.temperatureValue = 0xFF; // 无效值
            } else {
                this.temperatureValue = temperature + 40; // (值+40) = 传输值
            }
        }
        
        /**
         * 检查探针温度值是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isTemperatureValueValid() {
            return temperatureValue != 0xFE && temperatureValue != 0xFF;
        }
    }
    
    // 通过supercapacitorCellVoltages列表长度返回supercapacitorCellCount
    public int getSupercapacitorCellCount() {
        return supercapacitorCellVoltages == null ? 0 : supercapacitorCellVoltages.size();
    }
    
    // 通过temperatureValues列表长度返回temperatureProbeCount
    public int getTemperatureProbeCount() {
        return temperatureValues == null ? 0 : temperatureValues.size();
    }
}